import axios from 'axios'
import { Message } from 'element-ui'
import router from '@/router'

// 创建axios实例
const request = axios.create({
  // 开发环境下使用相对路径，生产环境使用完整URL
  // baseURL: process.env.NODE_ENV === 'development' ? 'http://localhost:1000' : 'http://localhost:1000',
  baseURL: 'http://39.106.50.183:1000',
  // 请求超时时间
  timeout: 10000,
  // 允许跨域携带cookie
  withCredentials: true,
  headers: {
    'Content-Type': 'application/json'
  }
})

// 请求拦截器
request.interceptors.request.use(
  config => {
    // 从localStorage获取token
    const userInfo = JSON.parse(localStorage.getItem('user') || '{}')
    if (userInfo.token) {
      config.headers['Authorization'] = `Bearer ${userInfo.token}`
    }
    
    // 如果是POST或PUT请求，确保数据被正确序列化
    if (config.method === 'post' || config.method === 'put') {
      if (typeof config.data === 'object') {
        // 检查是否包含MBTI测试结果的分数字段
        const isMBTIScoreData = data => {
          const mbtiScoreFields = ['eScore', 'iScore', 'sScore', 'nScore', 'tScore', 'fScore', 'jScore', 'pScore', 'mbtiType'];
          return mbtiScoreFields.some(field => data.hasOwnProperty(field));
        };
        
        // 检查是否为用户相关的请求
        const isUserData = data => {
          const userFields = ['userId', 'name', 'role', 'universityName', 'collegeName', 'majorName', 'grade', 'classId'];
          return userFields.some(field => data.hasOwnProperty(field));
        };
        
        if (isMBTIScoreData(config.data)) {
          // MBTI测试结果数据，保持原始格式
          console.log('检测到MBTI测试结果数据，保持原始格式:', config.data);
          config.data = JSON.stringify(config.data);
        } else if (isUserData(config.data)) {
          // 用户相关数据，保持原始格式
          console.log('检测到用户相关数据，保持原始格式:', config.data);
          
          // 特别处理：确保所有必填字段有值(不为null或undefined)
          const processedData = {...config.data};
          
          config.data = JSON.stringify(processedData);
        } else {
          // 其他数据，按照原有逻辑处理
          const processData = (data) => {
            const result = {}
            for (const key in data) {
              if (data[key] !== null && data[key] !== undefined) {
                if (typeof data[key] === 'string' && !isNaN(data[key]) && 
                    !key.toLowerCase().includes('score')) {
                  result[key] = Number(data[key])
                } else {
                  result[key] = data[key]
                }
              }
            }
            return result
          }
          config.data = JSON.stringify(processData(config.data))
        }
      }
    }
    
    // 添加调试信息
    console.log('Request Config:', {
      url: config.url,
      method: config.method,
      data: typeof config.data === 'string' ? JSON.parse(config.data) : config.data,
      headers: config.headers
    })
    
    return config
  },
  error => {
    console.error('请求错误：', error)
    return Promise.reject(error)
  }
)

// 响应拦截器
request.interceptors.response.use(
  response => {
    // 添加调试信息
    console.log('Response Data:', response.data)
    
    const res = response.data
    
    // 如果返回的是数组或普通对象，直接返回
    if (Array.isArray(res) || (typeof res === 'object' && !res.hasOwnProperty('code'))) {
      return { code: 200, data: res, message: 'success' }
    }
    
    // 如果返回的状态码不是200，说明接口有问题
    if (res.code !== 200) {
      // 添加详细的错误日志
      console.error('API返回错误:', {
        code: res.code,
        message: res.message || res.msg,
        url: response.config.url,
        method: response.config.method,
        data: response.config.data,
        response: res
      });
      
      // 对于登录接口，直接返回错误信息，让调用方处理
      if (response.config.url.includes('/checkLogin')) {
        return res
      }
      
      // 对于其他接口，显示错误消息
      Message({
        message: res.message || res.msg || '系统错误',
        type: 'error',
        duration: 5 * 1000
      })

      // 401: 未登录
      if (res.code === 401 || res.code === 403) {
        localStorage.removeItem('user')
        router.push('/admin/login')
      }
      
      // 特殊处理用户已存在的情况
      if ((res.message && res.message.includes('用户号已存在')) || 
          (res.msg && res.msg.includes('用户号已存在'))) {
        return Promise.reject(new Error('该用户号已注册，请直接登录'))
      }
      
      return Promise.reject(new Error(res.message || res.msg || '系统错误'))
    } else {
      // 确保返回的数据中的数字字段为数字类型
      if (res.data && typeof res.data === 'object') {
        // 检查是否为测试结果数据
        const isTestResult = res.data && (
          res.data.mbtiType || 
          res.data.mbtitype ||
          response.config.url.includes('testResults') ||
          Object.keys(res.data).some(key => 
            key.toLowerCase().includes('score') 
          )
        );
        
        if (isTestResult) {
          console.log('检测到测试结果数据，进行特殊处理');
          
          // 处理单个测试结果对象
          const processTestResult = (data) => {
            if (!data) return data;
            
            const result = { ...data };
            
            // 确保关键字段使用驼峰命名
            if (!result.mbtiType && result.mbtitype) {
              result.mbtiType = result.mbtitype;
            }
            
            // 分数字段列表
            const scoreFields = ['eScore', 'iScore', 'sScore', 'nScore', 'tScore', 'fScore', 'jScore', 'pScore'];
            const lowercaseFields = ['escore', 'iscore', 'sscore', 'nscore', 'tscore', 'fscore', 'jscore', 'pscore'];
            
            // 处理后端返回的小写字段，优先使用小写字段的值
            for (let i = 0; i < lowercaseFields.length; i++) {
              const lowercaseField = lowercaseFields[i];
              const camelCaseField = scoreFields[i];
              
              if (data[lowercaseField] !== undefined && data[lowercaseField] !== null) {
                // 将小写字段值转为数字并设置到驼峰字段
                const value = Number(data[lowercaseField]);
                result[camelCaseField] = isNaN(value) ? 0 : value;
              }
              // 如果小写字段不存在但驼峰字段存在，确保驼峰字段为数字类型
              else if (data[camelCaseField] !== undefined && data[camelCaseField] !== null) {
                const value = Number(data[camelCaseField]);
                result[camelCaseField] = isNaN(value) ? 0 : value;
              }
              // 如果两种字段都不存在，设置默认值0
              else {
                result[camelCaseField] = 0;
              }
            }
            
            // 计算并添加百分比字段（用于前端显示）
            // 计算各维度分数之和
            const eiSum = result.eScore + result.iScore;
            const snSum = result.sScore + result.nScore;
            const tfSum = result.tScore + result.fScore;
            const jpSum = result.jScore + result.pScore;
            
            // 添加百分比字段
            result.ePercentage = eiSum > 0 ? Math.round((result.eScore / eiSum) * 100) : 50;
            result.iPercentage = eiSum > 0 ? Math.round((result.iScore / eiSum) * 100) : 50;
            result.sPercentage = snSum > 0 ? Math.round((result.sScore / snSum) * 100) : 50;
            result.nPercentage = snSum > 0 ? Math.round((result.nScore / snSum) * 100) : 50;
            result.tPercentage = tfSum > 0 ? Math.round((result.tScore / tfSum) * 100) : 50;
            result.fPercentage = tfSum > 0 ? Math.round((result.fScore / tfSum) * 100) : 50;
            result.jPercentage = jpSum > 0 ? Math.round((result.jScore / jpSum) * 100) : 50;
            result.pPercentage = jpSum > 0 ? Math.round((result.pScore / jpSum) * 100) : 50;
            
            return result;
          };
          
          // 处理数据（单个对象或数组）
          if (Array.isArray(res.data)) {
            res.data = res.data.map(item => processTestResult(item));
          } else {
            res.data = processTestResult(res.data);
          }
          
          console.log('处理后的测试结果数据:', res.data);
        } else {
          // 非测试结果数据，进行通用处理
          const processData = (data) => {
            if (Array.isArray(data)) {
              return data.map(item => processData(item))
            }
            
            if (typeof data === 'object' && data !== null) {
              const result = {}
              
              for (const key in data) {
                if (data[key] !== null && data[key] !== undefined) {
                  if (typeof data[key] === 'object') {
                    result[key] = processData(data[key])
                  } else if (typeof data[key] === 'string' && !isNaN(data[key]) && 
                           (key.toLowerCase().includes('id') && key !== 'classId') || key === 'id') {
                    // 不要将classId转换为数字，即使它看起来像数字
                    result[key] = Number(data[key])
                  } else {
                    result[key] = data[key]
                  }
                }
              }
              
              return result
            }
            
            return data
          }
          
          res.data = processData(res.data)
        }
      }
      
      return res
    }
  },
  error => {
    // 添加详细的错误信息
    console.error('Response Error:', {
      message: error.message,
      config: error.config ? {
        url: error.config.url,
        method: error.config.method,
        data: error.config.data,
        headers: error.config.headers
      } : 'No config',
      response: error.response ? {
        status: error.response.status,
        data: error.response.data,
        headers: error.response.headers
      } : 'No response'
    })
    
    // 处理网络错误
    if (!error.response) {
      Message({
        message: '网络错误，请检查您的网络连接',
        type: 'error',
        duration: 5 * 1000
      })
      return Promise.reject(error)
    }
    
    // 处理后端返回的错误
    const status = error.response.status
    let message = error.response?.data?.message || error.response?.data?.msg || error.message || '系统错误'
    
    // 如果有详细错误信息，显示它
    if (error.response?.data?.data && typeof error.response.data.data === 'string') {
      message += `: ${error.response.data.data}`;
    }
    
    // 对于登录接口，直接返回错误信息，让调用方处理
    if (error.config && error.config.url && error.config.url.includes('/checkLogin')) {
      return Promise.reject({
        code: status,
        message: message
      })
    }
    
    switch (status) {
      case 400:
        message = `请求参数错误: ${message}`
        break
      case 401:
        message = '未登录或登录已过期'
        localStorage.removeItem('user')
        router.push('/admin/login')
        break
      case 403:
        message = '没有权限访问该资源'
        break
      case 404:
        message = '请求的资源不存在'
        break
      case 500:
        message = `服务器内部错误: ${message}`
        break
      default:
        message = `未知错误(${status}): ${message}`
    }
    
    Message({
      message: message,
      type: 'error',
      duration: 5 * 1000
    })
    return Promise.reject({
      code: status,
      message: message
    })
  }
)

export default request 